if (!dojo._hasResource["dojo._base.json"]) { //_hasResource checks added by build. Do not use _hasResource directly in your code.
    dojo._hasResource["dojo._base.json"] = true;
    dojo.provide("dojo._base.json");

    dojo.fromJson = function(/*String*/ json) {
        // summary:
        // 		Parses a [JSON](http://json.org) string to return a JavaScript object.
        // json:
        //		a string literal of a JSON item, for instance:
        //			`'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`

        return eval("(" + json + ")"); // Object
    }

    dojo._escapeString = function(/*String*/str) {
        //summary:
        //		Adds escape sequences for non-visual characters, double quote and
        //		backslash and surrounds with double quotes to form a valid string
        //		literal.
        return ('"' + str.replace(/(["\\])/g, '\\$1') + '"').
                replace(/[\f]/g, "\\f").replace(/[\b]/g, "\\b").replace(/[\n]/g, "\\n").
                replace(/[\t]/g, "\\t").replace(/[\r]/g, "\\r"); // string
    }

    dojo.toJsonIndentStr = "\t";
    dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint, /*String?*/ _indentStr) {
        // summary:
        //		Returns a [JSON](http://json.org) serialization of an object.
        //
        // description:
        //		Returns a [JSON](http://json.org) serialization of an object.
        //		Note that this doesn't check for infinite recursion, so don't do that!
        //
        // it:
        //		an object to be serialized. Objects may define their own
        //		serialization via a special "__json__" or "json" function
        //		property. If a specialized serializer has been defined, it will
        //		be used as a fallback.
        //
        // prettyPrint:
        //		if true, we indent objects and arrays to make the output prettier.
        //		The variable dojo.toJsonIndentStr is used as the indent string
        //		-- to use something other than the default (tab),
        //		change that variable before calling dojo.toJson().
        //
        // _indentStr:
        //		private variable for recursive calls when pretty printing, do not use.

        if (it === undefined) {
            return "undefined";
        }
        var objtype = typeof it;
        if (objtype == "number" || objtype == "boolean") {
            return it + "";
        }
        if (it === null) {
            return "null";
        }
        if (dojo.isString(it)) {
            return dojo._escapeString(it);
        }
        if (it.nodeType && it.cloneNode) { // isNode
            return ""; // FIXME: would something like outerHTML be better here?
        }
        // recurse
        var recurse = arguments.callee;
        // short-circuit for objects that support "json" serialization
        // if they return "self" then just pass-through...
        var newObj;
        _indentStr = _indentStr || "";
        var nextIndent = prettyPrint ? _indentStr + dojo.toJsonIndentStr : "";
        if (typeof it.__json__ == "function") {
            newObj = it.__json__();
            if (it !== newObj) {
                return recurse(newObj, prettyPrint, nextIndent);
            }
        }
        if (typeof it.json == "function") {
            newObj = it.json();
            if (it !== newObj) {
                return recurse(newObj, prettyPrint, nextIndent);
            }
        }

        var sep = prettyPrint ? " " : "";
        var newLine = prettyPrint ? "\n" : "";

        // array
        if (dojo.isArray(it)) {
            var res = dojo.map(it, function(obj) {
                var val = recurse(obj, prettyPrint, nextIndent);
                if (typeof val != "string") {
                    val = "undefined";
                }
                return newLine + nextIndent + val;
            });
            return "[" + res.join("," + sep) + newLine + _indentStr + "]";
        }
        /*
         // look in the registry
         try {
         window.o = it;
         newObj = dojo.json.jsonRegistry.match(it);
         return recurse(newObj, prettyPrint, nextIndent);
         }catch(e){
         // console.debug(e);
         }
         // it's a function with no adapter, skip it
         */
        if (objtype == "function") {
            return null; // null
        }
        // generic object code path
        var output = [];
        for (var key in it) {
            var keyStr;
            if (typeof key == "number") {
                keyStr = '"' + key + '"';
            } else if (typeof key == "string") {
                keyStr = dojo._escapeString(key);
            } else {
                // skip non-string or number keys
                continue;
            }
            val = recurse(it[key], prettyPrint, nextIndent);
            if (typeof val != "string") {
                // skip non-serializable values
                continue;
            }
            // FIXME: use += on Moz!!
            //	 MOW NOTE: using += is a pain because you have to account for the dangling comma...
            output.push(newLine + nextIndent + keyStr + ":" + sep + val);
        }
        return "{" + output.join("," + sep) + newLine + _indentStr + "}"; // String
    }

}
